\section{Mesh}
		\subsection{Concept d'objets 3D}  
		L'idée de base du Mesh était de créer un objet en trois dimensions générique, que l'on pourrait facilement charger, puis dessiner.
		Nous voulions un objet qui soit facile à utiliser , qui serait hors de la complexité d'OpenGL. Pour celà nous avons créé deux
		objets, le MeshData qui contient tous les tableaux de points, de normales, d'indices, ainsi que la taille de ceux-ci. Cet objet 
		est contenu dans notre autre objet, le Mesh qui contient en plus des tableaux, une texture, une position en trois dimensions,
		une rotation sur les trois axes x, y et z , un angle, un matériau pour les éclairages. Cet objet contient les observateurs 
		et les assesseurs nécessaires à sa modification complète. Avec le Mesh, nous pouvons facilement charger un objet à partir d'un fichier
		et le dessiner en tapant monobjet.draw(), au lieu de devoir le coder avec les fonctions OpenGL. 
		\begin{lstlisting}
 class SHARED Mesh : public IDrawable
{	

public :

	
	Mesh(MeshData *data = NULL, bool useVBO = true, GLenum update_type = STREAM);
	~Mesh();
	
	void setTexture(std::string filename);
	void genNormals(bool inv = false);
	const Vector3d &getPos() const;
	const Vector3d &getAxes() const;	
	const Vector3f &getScale() const;	
	float getAngle() const;
	const float * getVertices() const;
	const unsigned int * getIndex() const;
	const float * getTexCoords() const;
	const float * getNormals() const;
	unsigned int getNbVertices() const;
	unsigned int getNbIndex() const;
	unsigned int getNbTexCoord() const;
	unsigned int getNbNormals() const;
	
	/* accesseurs */
	void setPos(const Vector3d &pos);
	void setAngle(float angle, const Vector3d &axes);
	void setScale(const Vector3f &scale);

	// Materials
	
	void setAmbient(const Color4f &color);
	void setDiffuse(const Color4f &color);
	void setSpecular(const Color4f &color);
	void setShininess(int sh);
	
	virtual void draw() const;
	void drawNormals() const;

private:

	void create();
	
	void normcrossprod(float v1[3], float v2[3], float out[3]);
	void createnormal(float *v1, float *v2, float *v3,float *out);
	void addnormal(float *n, float *newnorm);
	void normalize(float v[3]);
	
	bool _useVBO;
	GLenum _update_type;
	MeshData *_data;
	Texture *_texture;
	IBuffer **_vbo;
	Material _m;
	
	Vector3d _pos, _axes;
	Vector3f _scale;
	float _angle;
	
};
		\end{lstlisting}		
		\subsection{Chargement de Fichiers de Points}  
		Pour le chargement des fichiers nous avons créé un chargeur de fichiers virtuel le ILoader, qui contient une fonction load,
		qui permet de charger n'importe quoi (c'est beau l'informatique!!). Ensuite nous avons dérivé des Loaders spécifiques pour un 
		type de fichiers. Ces classes créent un MeshData * puis mettent a jour, en accord avec le fichier, les différents tableaux 
		de données, puis renvoient le pointeur au constructeur de Mesh , qui récupère les tableaux.
		Il suffit donc pour rajouter un type de fichier chargeable, de créer un nouveau Loader qui prend un nom de fichier en paramètre
		et qui renvoi un MeshData *  en modifiant les tableaux. Pour que ce chargeur soit pris en compte par la librairie, se référer à
		la partie suivante.
		\begin{lstlisting}
template<class T>
class SHARED ILoader
{

	public :
		virtual T* load(std::string ext) = 0;

	private :

};
		\end{lstlisting}		
		\subsection{La Mesh-Factory}  
			\paragraph{MeshFactory}
			La MeshFactory, est la classe qui permet de créer des Meshs , elle contient une std::map<string, ILoader*> qui est le lien 
			entre les extensions de fichiers et les chargeurs correspondants à ces fichiers. Elle contient deux fonctions et la map.
			Ces fonctions sont registerMeshLoader(std::string ext, ILoader<MeshData> *loader), qui va remplir la map, et donc permettre 
			de stocker le lien entre un type de fichier et un Loader. La seconde fonction est la fonction Mesh *create(std::string filename),
			qui prend en paramètre le nom de fichier, mais la Factory va renvoyer TheMap["mon extension"]::create(filename), qui renvoye le 
			Mesh créé car TheMap["MonExtension"] vas retourner le Loader associé au fichier.
			
			\paragraph{MeshFactoryBuilder}
			C'est le remplisseur de la Factory, c'est lui qui utilise la fonction register. il va donc permettre de dire à la librarie, 
			qu'une extension est liée à un chargeur. on déclare une instance static pour qu'il se crée et charge la map dès le debut du programme
			et remplisse la map. Pour rajouter un nouveau type de fichier chargeable: 
			Créer un fichier MONEXTBuilder.h, et créer une classe monextBuilder, il faut inclure le header du chargeur de votre type de fichier 
			à charger, mettre la ligne MeshFactory::registerMeshLoader("monExt", new LoaderMONEXT()); dans le constructeur de la classe, et finalement
			déclarer une instance static de la classe  en dehors de la classe, et inclure votre nouveau header dans votre main.\\
			Exemple d'ajout de nouvelle extension chargeable :
			\begin{lstlisting}
#include "LoaderMYEXTENSION.h"
class SHARED MyExtensionBuilder
{
public :
	
	MyExtensionBuilder()
	{
		MeshFactory::registerMeshLoader(".myextension", new LoaderMYEXTENSION());
	}		
};

static MyExtensionBuilder TheMyExtensionBuilder;
			\end{lstlisting}			
